#include "Assert.h"

private_ static_ int_ counter;

public static_ void space(NUnit_Assert,dAreEqual)(decimal expected, decimal actual)
{
    space(NUnit_Assert,dAreEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,iAreEqual)(int_ expected, int_ actual)
{
    space(NUnit_Assert,iAreEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,lAreEqual)(long_ expected, long_ actual)
{
    space(NUnit_Assert,lAreEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,oAreEqual)(object expected, object actual)
{
    space(NUnit_Assert,oAreEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,uiAreEqual)(uint expected, uint actual)
{
    space(NUnit_Assert,uiAreEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,ulAreEqual)(ulong expected, ulong actual)
{
    space(NUnit_Assert,ulAreEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,dAreEqual2)(decimal expected, decimal actual, string message)
{
    space(NUnit_Assert,dAreEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,rAreEqual)(double expected, double actual, double delta)
{
    space(NUnit_Assert,rAreEqual3)(expected, actual, delta, string_Empty, null);
}
public static_ void space(NUnit_Assert,iAreEqual2)(int_ expected, int_ actual, string message)
{
    space(NUnit_Assert,iAreEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,lAreEqual2)(long_ expected, long_ actual, string message)
{
    space(NUnit_Assert,lAreEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,oAreEqual2)(object expected, object actual, string message)
{
    space(NUnit_Assert,oAreEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,fAreEqual)(float expected, float actual, float delta)
{
    space(NUnit_Assert,fAreEqual3)(expected, actual, delta, string_Empty, null);
}
public static_ void space(NUnit_Assert,uiAreEqual2)(uint expected, uint actual, string message)
{
    space(NUnit_Assert,uiAreEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,ulAreEqual2)(ulong expected, ulong actual, string message)
{
    space(NUnit_Assert,ulAreEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,dAreEqual3)(decimal expected, decimal actual, string message, params object args[])
{
    space(NUnit_Assert,oThat3)(__box(decimal,actual), (NUnit_Constraints_Constraint *)space(NUnit_SyntaxHelpers_Is,EqualTo)(__box(decimal,expected)), message, args);
}
public static_ void space(NUnit_Assert,rAreEqual2)(double expected, double actual, double delta, string message)
{
    space(NUnit_Assert,rAreEqual3)(expected, actual, delta, message, null);
}
public static_ void space(NUnit_Assert,iAreEqual3)(int_ expected, int_ actual, string message, params object args[])
{
    space(NUnit_Assert,oThat3)(__box(int_,actual), (NUnit_Constraints_Constraint *)space(NUnit_SyntaxHelpers_Is,EqualTo)(__box(int_,expected)), message, args);
}
public static_ void space(NUnit_Assert,lAreEqual3)(long_ expected, long_ actual, string message, params object args[])
{
    space(NUnit_Assert,oThat3)(__box(long_,actual), (NUnit_Constraints_Constraint *)space(NUnit_SyntaxHelpers_Is,EqualTo)(__box(long_,expected)), message, args);
}
public static_ void space(NUnit_Assert,oAreEqual3)(object expected, object actual, string message, params object args[])
{
    space(NUnit_Assert,oThat3)(actual, (NUnit_Constraints_Constraint *)space(NUnit_SyntaxHelpers_Is,EqualTo)(expected), message, args);
}
public static_ void space(NUnit_Assert,fAreEqual2)(float expected, float actual, float delta, string message)
{
    space(NUnit_Assert,fAreEqual3)(expected, actual, delta, message, null);
}
public static_ void space(NUnit_Assert,uiAreEqual3)(uint expected, uint actual, string message, params object args[])
{
    space(NUnit_Assert,oThat3)(__box(uint,actual), (NUnit_Constraints_Constraint *)space(NUnit_SyntaxHelpers_Is,EqualTo)(__box(uint,expected)), message, args);
}
public static_ void space(NUnit_Assert,ulAreEqual3)(ulong expected, ulong actual, string message, params object args[])
{
    space(NUnit_Assert,oThat3)(__box(ulong,actual), (NUnit_Constraints_Constraint *)space(NUnit_SyntaxHelpers_Is,EqualTo)(__box(ulong,expected)), message, args);
}
public static_ void space(NUnit_Assert,rAreEqual3)(double expected, double actual, double delta, string message, params object args[])
{
    //Constraint constraint = new EqualConstraint(expected);
    //if (double.IsNaN(expected) || double.IsInfinity(expected))
    //{
    //    space(NUnit_Assert,That)(actual, space(NUnit_SyntaxHelpers_Is,EqualTo)(expected), message, args);
    //}
    //else
    //{
    //    space(NUnit_Assert,That)(actual, space(NUnit_SyntaxHelpers_Is,EqualTo)(expected).Within(delta), message, args);
    //}
}
public static_ void space(NUnit_Assert,fAreEqual3)(float expected, float actual, float delta, string message, params object args[])
{
    //if (float.IsNaN(expected) || float.IsInfinity(expected))
    //{
    //    space(NUnit_Assert,That)(actual, space(NUnit_SyntaxHelpers_Is,EqualTo)(expected), message, args);
    //}
    //else
    //{
    //    space(NUnit_Assert,That)(actual, space(NUnit_SyntaxHelpers_Is,EqualTo)(expected).Within(delta), message, args);
    //}
}

public static_ void space(NUnit_Assert,dAreNotEqual)(decimal expected, decimal actual)
{
    space(NUnit_Assert,dAreNotEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,rAreNotEqual)(double expected, double actual)
{
    space(NUnit_Assert,rAreNotEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,iAreNotEqual)(int_ expected, int_ actual)
{
    space(NUnit_Assert,iAreNotEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,lAreNotEqual)(long_ expected, long_ actual)
{
    space(NUnit_Assert,lAreNotEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,oAreNotEqual)(object expected, object actual)
{
    space(NUnit_Assert,oAreNotEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,fAreNotEqual)(float expected, float actual)
{
    space(NUnit_Assert,fAreNotEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,uiAreNotEqual)(uint expected, uint actual)
{
    space(NUnit_Assert,uiAreNotEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,ulAreNotEqual)(ulong expected, ulong actual)
{
    space(NUnit_Assert,ulAreNotEqual3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,dAreNotEqual2)(decimal expected, decimal actual, string message)
{
    space(NUnit_Assert,dAreNotEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,rAreNotEqual2)(double expected, double actual, string message)
{
    space(NUnit_Assert,rAreNotEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,iAreNotEqual2)(int_ expected, int_ actual, string message)
{
    space(NUnit_Assert,iAreNotEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,lAreNotEqual2)(long_ expected, long_ actual, string message)
{
    space(NUnit_Assert,lAreNotEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,oAreNotEqual2)(object expected, object actual, string message)
{
    space(NUnit_Assert,oAreNotEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,fAreNotEqual2)(float expected, float actual, string message)
{
    space(NUnit_Assert,fAreNotEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,uiAreNotEqual2)(uint expected, uint actual, string message)
{
    space(NUnit_Assert,uiAreNotEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,ulAreNotEqual2)(ulong expected, ulong actual, string message)
{
    space(NUnit_Assert,ulAreNotEqual3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,dAreNotEqual3)(decimal expected, decimal actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.Not.EqualTo(expected), message, args);
}
public static_ void space(NUnit_Assert,rAreNotEqual3)(double expected, double actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.Not.EqualTo(expected), message, args);
}
public static_ void space(NUnit_Assert,iAreNotEqual3)(int_ expected, int_ actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.Not.EqualTo(expected), message, args);
}
public static_ void space(NUnit_Assert,lAreNotEqual3)(long_ expected, long_ actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.Not.EqualTo(expected), message, args);
}
public static_ void space(NUnit_Assert,oAreNotEqual3)(object expected, object actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.Not.EqualTo(expected), message, args);
}
public static_ void space(NUnit_Assert,fAreNotEqual3)(float expected, float actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.Not.EqualTo(expected), message, args);
}
public static_ void space(NUnit_Assert,uiAreNotEqual3)(uint expected, uint actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.Not.EqualTo(expected), message, args);
}
public static_ void space(NUnit_Assert,ulAreNotEqual3)(ulong expected, ulong actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.Not.EqualTo(expected), message, args);
}

public static_ void space(NUnit_Assert,oAreNotSame)(object expected, object actual)
{
    space(NUnit_Assert,oAreNotSame3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,oAreNotSame2)(object expected, object actual, string message)
{
    space(NUnit_Assert,oAreNotSame3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,oAreNotSame3)(object expected, object actual, string message, params object args[])
{
   //space(NUnit_Assert,oThat3)(actual, NUnit_SyntaxHelpers_Is.Not.SameAs(expected), message, args);
}

public static_ void space(NUnit_Assert,oAreSame)(object expected, object actual)
{
    space(NUnit_Assert,oAreSame3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,oAreSame2)(object expected, object actual, string message)
{
    space(NUnit_Assert,oAreSame3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,oAreSame3)(object expected, object actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.SameAs(expected), message, args);
}

public static_ void space(NUnit_Assert,oContains)(object expected, Collections_ICollection(System_Object) *actual)
{
    //space(NUnit_Assert,oContains3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,oContains2)(object expected, Collections_ICollection(System_Object) *actual, string message)
{
    //space(NUnit_Assert,oContains3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,oContains3)(object expected, Collections_ICollection(System_Object) *actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, new CollectionContainsConstraint(expected), message, args);
}

public static_ bool space(NUnit_Assert,Equals)(object a, object b)
{
    throw(AssertionException, L"Assert.Equals should not be used for Assertions");
}

public static_ void space(NUnit_Assert,Fail)()
{
    space(NUnit_Assert,Fail3)(string_Empty, null);
}
public static_ void space(NUnit_Assert,Fail2)(string message)
{
    space(NUnit_Assert,Fail3)(message, null);
}
public static_ void space(NUnit_Assert,Fail3)(string message, params object args[])
{
    if (message == null)
    {
        message = string_Empty;
    }
    else if ((args != null) && (array_getLength(args) > 0))
    {
        message = string_Format(message, args);
    }
    throw(AssertionException, message);
}

public static_ void space(NUnit_Assert,dGreater)(decimal arg1, decimal arg2)
{
    space(NUnit_Assert,dGreater3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,rGreater)(double arg1, double arg2)
{
    space(NUnit_Assert,rGreater3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,xGreater)(System_IComparable(System_Object) *arg1, System_IComparable(System_Object) *arg2)
{
    space(NUnit_Assert,xGreater3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,iGreater)(int_ arg1, int_ arg2)
{
    space(NUnit_Assert,iGreater3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,lGreater)(long_ arg1, long_ arg2)
{
    space(NUnit_Assert,lGreater3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,fGreater)(float arg1, float arg2)
{
    space(NUnit_Assert,fGreater3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,uiGreater)(uint arg1, uint arg2)
{
    space(NUnit_Assert,uiGreater3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,ulGreater)(ulong arg1, ulong arg2)
{
    space(NUnit_Assert,ulGreater3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,dGreater2)(decimal arg1, decimal arg2, string message)
{
    space(NUnit_Assert,dGreater3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,rGreater2)(double arg1, double arg2, string message)
{
    space(NUnit_Assert,rGreater3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,xGreater2)(System_IComparable(System_Object) *arg1, System_IComparable(System_Object) *arg2, string message)
{
    space(NUnit_Assert,xGreater3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,iGreater2)(int_ arg1, int_ arg2, string message)
{
    space(NUnit_Assert,iGreater3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,lGreater2)(long_ arg1, long_ arg2, string message)
{
    space(NUnit_Assert,lGreater3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,fGreater2)(float arg1, float arg2, string message)
{
    space(NUnit_Assert,fGreater3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,uiGreater2)(uint arg1, uint arg2, string message)
{
    space(NUnit_Assert,uiGreater3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,ulGreater2)(ulong arg1, ulong arg2, string message)
{
    space(NUnit_Assert,ulGreater3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,dGreater3)(decimal arg1, decimal arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,rGreater3)(double arg1, double arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,xGreater3)(System_IComparable(System_Object) *arg1, System_IComparable(System_Object) *arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,iGreater3)(int_ arg1, int_ arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,lGreater3)(long_ arg1, long_ arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,fGreater3)(float arg1, float arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,uiGreater3)(uint arg1, uint arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,ulGreater3)(ulong arg1, ulong arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThan(arg2), message, args);
}

public static_ void space(NUnit_Assert,dGreaterOrEqual)(decimal arg1, decimal arg2)
{
    space(NUnit_Assert,dGreaterOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,rGreaterOrEqual)(double arg1, double arg2)
{
    space(NUnit_Assert,rGreaterOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,xGreaterOrEqual)(System_IComparable(System_Object) *arg1, System_IComparable(System_Object) *arg2)
{
    space(NUnit_Assert,xGreaterOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,iGreaterOrEqual)(int_ arg1, int_ arg2)
{
    space(NUnit_Assert,iGreaterOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,lGreaterOrEqual)(long_ arg1, long_ arg2)
{
    space(NUnit_Assert,lGreaterOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,fGreaterOrEqual)(float arg1, float arg2)
{
    space(NUnit_Assert,fGreaterOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,uiGreaterOrEqual)(uint arg1, uint arg2)
{
    space(NUnit_Assert,uiGreaterOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,ulGreaterOrEqual)(ulong arg1, ulong arg2)
{
    space(NUnit_Assert,ulGreaterOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,dGreaterOrEqual2)(decimal arg1, decimal arg2, string message)
{
    space(NUnit_Assert,dGreaterOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,rGreaterOrEqual2)(double arg1, double arg2, string message)
{
    space(NUnit_Assert,rGreaterOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,xGreaterOrEqual2)(System_IComparable(System_Object) *arg1, System_IComparable(System_Object) *arg2, string message)
{
    space(NUnit_Assert,xGreaterOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,iGreaterOrEqual2)(int_ arg1, int_ arg2, string message)
{
    space(NUnit_Assert,iGreaterOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,lGreaterOrEqual2)(long_ arg1, long_ arg2, string message)
{
    space(NUnit_Assert,lGreaterOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,fGreaterOrEqual2)(float arg1, float arg2, string message)
{
    space(NUnit_Assert,fGreaterOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,uiGreaterOrEqual2)(uint arg1, uint arg2, string message)
{
    space(NUnit_Assert,uiGreaterOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,ulGreaterOrEqual2)(ulong arg1, ulong arg2, string message)
{
    space(NUnit_Assert,ulGreaterOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,dGreaterOrEqual3)(decimal arg1, decimal arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,rGreaterOrEqual3)(double arg1, double arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,xGreaterOrEqual3)(System_IComparable(System_Object) *arg1, System_IComparable(System_Object) *arg2, string message, params object args[])
{
    //space(NUnit_Assert,Thatspace(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,iGreaterOrEqual3)(int_ arg1, int_ arg2, string message, params object args[])
{
    //space(NUnit_Assert,Thatspace(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,lGreaterOrEqual3)(long_ arg1, long_ arg2, string message, params object args[])
{
    //space(NUnit_Assert,Thatspace(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,fGreaterOrEqual3)(float arg1, float arg2, string message, params object args[])
{
    //space(NUnit_Assert,Thatspace(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,uiGreaterOrEqual3)(uint arg1, uint arg2, string message, params object args[])
{
    //space(NUnit_Assert,Thatspace(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,ulGreaterOrEqual3)(ulong arg1, ulong arg2, string message, params object args[])
{
    //space(NUnit_Assert,Thatspace(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.GreaterThanOrEqualTo(arg2), message, args);
}

public static_ void space(NUnit_Assert,Ignore)()
{
    space(NUnit_Assert,Ignore3)(string_Empty, null);
}
public static_ void space(NUnit_Assert,Ignore2)(string message)
{
    space(NUnit_Assert,Ignore3)(message, null);
}
public static_ void space(NUnit_Assert,Ignore3)(string message, params object args[])
{
    if (message == null)
    {
        message = string_Empty;
    }
    else if ((args != null) && (array_getLength(args) > 0))
    {
        message = string_Format(message, args);
    }
    throw(IgnoreException,message);
}

private static_ void IncrementAssertCount()
{
    counter++;
}

public static_ void space(NUnit_Assert,xIsAssignableFrom)(System_Type *expected, object actual)
{
    space(NUnit_Assert,xIsAssignableFrom3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,xIsAssignableFrom2)(System_Type *expected, object actual, string message)
{
    space(NUnit_Assert,xIsAssignableFrom3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,xIsAssignableFrom3)(System_Type *expected, object actual, string message, params object args[])
{
    //space(NUnit_Assert,Thatspace(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.AssignableFrom(expected), message, args);
}

public static_ void space(NUnit_Assert,xIsEmpty)(Collections_ICollection(System_Object) *collection)
{
    space(NUnit_Assert,xIsEmpty3)(collection, string_Empty, null);
}
public static_ void space(NUnit_Assert,sIsEmpty)(string aString)
{
    space(NUnit_Assert,sIsEmpty3)(aString, string_Empty, null);
}
public static_ void space(NUnit_Assert,xIsEmpty2)(Collections_ICollection(System_Object) *collection, string message)
{
    space(NUnit_Assert,xIsEmpty3)(collection, message, null);
}
public static_ void space(NUnit_Assert,sIsEmpty2)(string aString, string message)
{
    space(NUnit_Assert,sIsEmpty3)(aString, message, null);
}
public static_ void space(NUnit_Assert,xIsEmpty3)(Collections_ICollection(System_Object) *collection, string message, params object args[])
{
    //space(NUnit_Assert,That)(collection, new EmptyCollectionConstraint(), message, args);
}
public static_ void space(NUnit_Assert,sIsEmpty3)(string aString, string message, params object args[])
{
    //space(NUnit_Assert,That)(aString, new EmptyStringConstraint(), message, args);
}

public static_ void space(NUnit_Assert,bIsFalse)(bool condition)
{
    space(NUnit_Assert,bIsFalse3)(condition, string_Empty, null);
}
public static_ void space(NUnit_Assert,bIsFalse2)(bool condition, string message)
{
    space(NUnit_Assert,bIsFalse3)(condition, message, null);
}
public static_ void space(NUnit_Assert,bIsFalse3)(bool condition, string message, params object args[])
{
    //space(NUnit_Assert,That)(condition, NUnit_SyntaxHelpers_Is.False, message, args);
}

public static_ void space(NUnit_Assert,xIsInstanceOfType)(System_Type *expected, object actual)
{
    space(NUnit_Assert,xIsInstanceOfType3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,xIsInstanceOfType2)(System_Type *expected, object actual, string message)
{
    space(NUnit_Assert,xIsInstanceOfType3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,xIsInstanceOfType3)(System_Type *expected, object actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.InstanceOfType(expected), message, args);
}

public static_ void space(NUnit_Assert,rIsNaN)(double aDouble)
{
    space(NUnit_Assert,rIsNaN3)(aDouble, string_Empty, null);
}
public static_ void space(NUnit_Assert,rIsNaN2)(double aDouble, string message)
{
    space(NUnit_Assert,rIsNaN3)(aDouble, message, null);
}
public static_ void space(NUnit_Assert,rIsNaN3)(double aDouble, string message, params object args[])
{
    //space(NUnit_Assert,That)(aDouble, NUnit_SyntaxHelpers_Is.NaN, message, args);
}

public static_ void space(NUnit_Assert,xIsNotAssignableFrom)(System_Type *expected, object actual)
{
    space(NUnit_Assert,xIsNotAssignableFrom3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,xIsNotAssignableFrom2)(System_Type *expected, object actual, string message)
{
    space(NUnit_Assert,xIsNotAssignableFrom3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,xIsNotAssignableFrom3)(System_Type *expected, object actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.Not.AssignableFrom(expected), message, args);
}

public static_ void space(NUnit_Assert,xIsNotEmpty)(Collections_ICollection(System_Object) *collection)
{
    //space(NUnit_Assert,xIsNotEmpty3)(collection, string_Empty, null);
}
public static_ void space(NUnit_Assert,sIsNotEmpty)(string aString)
{
    space(NUnit_Assert,sIsNotEmpty3)(aString, string_Empty, null);
}
public static_ void space(NUnit_Assert,xIsNotEmpty2)(Collections_ICollection(System_Object) *collection, string message)
{
    space(NUnit_Assert,xIsNotEmpty3)(collection, message, null);
}
public static_ void space(NUnit_Assert,sIsNotEmpty2)(string aString, string message)
{
    space(NUnit_Assert,sIsNotEmpty3)(aString, message, null);
}
public static_ void space(NUnit_Assert,xIsNotEmpty3)(Collections_ICollection(System_Object) *collection, string message, params object args[])
{
    //space(NUnit_Assert,That)(collection, NUnit_SyntaxHelpers_Is.Not.Empty, message, args);
}
public static_ void space(NUnit_Assert,sIsNotEmpty3)(string aString, string message, params object args[])
{
    //space(NUnit_Assert,That)(aString, NUnit_SyntaxHelpers_Is.Not.Empty, message, args);
}

public static_ void space(NUnit_Assert,xIsNotInstanceOfType)(System_Type *expected, object actual)
{
    space(NUnit_Assert,xIsNotInstanceOfType3)(expected, actual, string_Empty, null);
}
public static_ void space(NUnit_Assert,xIsNotInstanceOfType2)(System_Type *expected, object actual, string message)
{
    space(NUnit_Assert,xIsNotInstanceOfType3)(expected, actual, message, null);
}
public static_ void space(NUnit_Assert,xIsNotInstanceOfType3)(System_Type *expected, object actual, string message, params object args[])
{
    //space(NUnit_Assert,That)(actual, NUnit_SyntaxHelpers_Is.Not.InstanceOfType(expected), message, args);
}

public static_ void space(NUnit_Assert,oIsNotNull)(object anObject)
{
    space(NUnit_Assert,oIsNotNull3)(anObject, string_Empty, null);
}
public static_ void space(NUnit_Assert,oIsNotNull2)(object anObject, string message)
{
    space(NUnit_Assert,oIsNotNull3)(anObject, message, null);
}
public static_ void space(NUnit_Assert,oIsNotNull3)(object anObject, string message, params object args[])
{
    //space(NUnit_Assert,That)(anObject, NUnit_SyntaxHelpers_Is.Not.Null, message, args);
}

public static_ void space(NUnit_Assert,oIsNull)(object anObject)
{
    space(NUnit_Assert,oIsNull3)(anObject, string_Empty, null);
}
public static_ void space(NUnit_Assert,oIsNull2)(object anObject, string message)
{
    space(NUnit_Assert,oIsNull3)(anObject, message, null);
}
public static_ void space(NUnit_Assert,oIsNull3)(object anObject, string message, params object args[])
{
    //space(NUnit_Assert,That)(anObject, NUnit_SyntaxHelpers_Is.Null, message, args);
}

public static_ void space(NUnit_Assert,bIsTrue)(bool condition)
{
    space(NUnit_Assert,bIsTrue3)(condition, null, null);
}
public static_ void space(NUnit_Assert,bIsTrue2)(bool condition, string message)
{
    space(NUnit_Assert,bIsTrue3)(condition, message, null);
}
public static_ void space(NUnit_Assert,bIsTrue3)(bool condition, string message, params object args[])
{
    //space(NUnit_Assert,That)(condition, NUnit_SyntaxHelpers_Is.True, message, args);
}

public static_ void space(NUnit_Assert,dLess)(decimal arg1, decimal arg2)
{
    space(NUnit_Assert,dLess3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,rLess)(double arg1, double arg2)
{
    space(NUnit_Assert,rLess3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,xLess)(System_IComparable(System_Object) *arg1, System_IComparable(System_Object) *arg2)
{
    space(NUnit_Assert,xLess3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,iLess)(int_ arg1, int_ arg2)
{
    space(NUnit_Assert,iLess3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,lLess)(long_ arg1, long_ arg2)
{
    space(NUnit_Assert,lLess3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,fLess)(float arg1, float arg2)
{
    space(NUnit_Assert,fLess3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,uiLess)(uint arg1, uint arg2)
{
    space(NUnit_Assert,uiLess3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,ulLess)(ulong arg1, ulong arg2)
{
    space(NUnit_Assert,ulLess3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,dLess2)(decimal arg1, decimal arg2, string message)
{
    space(NUnit_Assert,dLess3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,rLess2)(double arg1, double arg2, string message)
{
    space(NUnit_Assert,rLess3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,Less2)(System_IComparable(System_Object) *arg1, System_IComparable(System_Object) *arg2, string message)
{
    space(NUnit_Assert,xLess3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,iLess2)(int_ arg1, int_ arg2, string message)
{
    space(NUnit_Assert,iLess3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,lLess2)(long_ arg1, long_ arg2, string message)
{
    space(NUnit_Assert,lLess3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,fLess2)(float arg1, float arg2, string message)
{
    space(NUnit_Assert,fLess3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,uiLess2)(uint arg1, uint arg2, string message)
{
    space(NUnit_Assert,uiLess3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,ulLess2)(ulong arg1, ulong arg2, string message)
{
    space(NUnit_Assert,ulLess3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,dLess3)(decimal arg1, decimal arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,rLess3)(double arg1, double arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,xLess3)(System_IComparable(System_Object) *arg1, System_IComparable(System_Object) *arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,iLess3)(int_ arg1, int_ arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,lLess3)(long_ arg1, long_ arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,fLess3)(float arg1, float arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,uiLess3)(uint arg1, uint arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThan(arg2), message, args);
}
public static_ void space(NUnit_Assert,ulLess3)(ulong arg1, ulong arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThan(arg2), message, args);
}

public static_ void space(NUnit_Assert,dLessOrEqual)(decimal arg1, decimal arg2)
{
    space(NUnit_Assert,dLessOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,rLessOrEqual)(double arg1, double arg2)
{
    space(NUnit_Assert,rLessOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,xLessOrEqual)(System_IComparable(System_Object) *arg1, System_IComparable(System_Object) *arg2)
{
    space(NUnit_Assert,xLessOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,iLessOrEqual)(int_ arg1, int_ arg2)
{
    space(NUnit_Assert,iLessOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,lLessOrEqual)(long_ arg1, long_ arg2)
{
    space(NUnit_Assert,lLessOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,fLessOrEqual)(float arg1, float arg2)
{
    space(NUnit_Assert,fLessOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,uiLessOrEqual)(uint arg1, uint arg2)
{
    space(NUnit_Assert,uiLessOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,ulLessOrEqual)(ulong arg1, ulong arg2)
{
    space(NUnit_Assert,ulLessOrEqual3)(arg1, arg2, string_Empty, null);
}
public static_ void space(NUnit_Assert,dLessOrEqual2)(decimal arg1, decimal arg2, string message)
{
    space(NUnit_Assert,dLessOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,rLessOrEqual2)(double arg1, double arg2, string message)
{
    space(NUnit_Assert,rLessOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,xLessOrEqual2)(System_IComparable(System_Object) *arg1, System_IComparable(System_Object) *arg2, string message)
{
    space(NUnit_Assert,xLessOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,iLessOrEqual2)(int_ arg1, int_ arg2, string message)
{
    space(NUnit_Assert,iLessOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,lLessOrEqua2l)(long_ arg1, long_ arg2, string message)
{
    space(NUnit_Assert,lLessOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,fLessOrEqual2)(float arg1, float arg2, string message)
{
    space(NUnit_Assert,fLessOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,uiLessOrEqual2)(uint arg1, uint arg2, string message)
{
    space(NUnit_Assert,uiLessOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,ulLessOrEqual2)(ulong arg1, ulong arg2, string message)
{
    space(NUnit_Assert,ulLessOrEqual3)(arg1, arg2, message, null);
}
public static_ void space(NUnit_Assert,dLessOrEqual3)(decimal arg1, decimal arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,rLessOrEqual3)(double arg1, double arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,xLessOrEqual3)(System_IComparable(System_Object) *arg1, System_IComparable(System_Object) *arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,iLessOrEqual3)(int_ arg1, int_ arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,lLessOrEqual3)(long_ arg1, long_ arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,fLessOrEqual3)(float arg1, float arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,uiLessOrEqual3)(uint arg1, uint arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThanOrEqualTo(arg2), message, args);
}
public static_ void space(NUnit_Assert,ulLessOrEqual3)(ulong arg1, ulong arg2, string message, params object args[])
{
    //space(NUnit_Assert,That)(arg1, NUnit_SyntaxHelpers_Is.LessThanOrEqualTo(arg2), message, args);
}

public static_ void space(NUnit_Assert,bThat)(bool condition)
{
    space(NUnit_Assert,oThat3)(__box(bool,condition), space(NUnit_SyntaxHelpers_Is,True), null, null);
}
public static_ void space(NUnit_Assert,bThat2)(bool condition, string message)
{
    space(NUnit_Assert,oThat3)(__box(bool,condition), space(NUnit_SyntaxHelpers_Is,True), message, null);
}
public static_ void space(NUnit_Assert,oThat)(object actual, NUnit_Constraints_Constraint *constraint)
{
    space(NUnit_Assert,oThat3)(actual, constraint, null, null);
}
public static_ void space(NUnit_Assert,bThat3)(bool condition, string message, params object args[])
{
    space(NUnit_Assert,oThat3)(__box(bool,condition), space(NUnit_SyntaxHelpers_Is,True), message, args);
}
public static_ void space(NUnit_Assert,oThat2)(object actual, NUnit_Constraints_Constraint *constraint, string message)
{
    space(NUnit_Assert,oThat3)(actual, constraint, message, null);
}
public static_ void space(NUnit_Assert,oThat3)(object actual, NUnit_Constraints_Constraint *constraint, string message, params object args[])
{
    IncrementAssertCount();
	if (!vcall(NUnit_Constraints_Constraint,constraint,Matches,actual))
	{
    //    MessageWriter writer = new TextMessageWriter(message, args);
    //    constraint.WriteMessageTo(writer);
		throw(AssertionException, L"writer.ToString()");
	}
}
